package com.jzo2o.common.utils;

import cn.hutool.core.util.NumberUtil;

import java.math.BigDecimal;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 数字操作工具类，继承hutool的NumberUtil并扩展空值处理、格式化、统计等功能
 */
public class NumberUtils extends NumberUtil {


    /**
     * 空值处理：Integer为空时返回0，否则返回原值
     * @param number 原数值
     * @return 处理后的Integer
     */
    public static Integer null2Zero(Integer number){
        return number == null ? 0 : number;
    }

    /**
     * 空值处理：Double为空时返回0，否则返回原值
     * @param number 原数值
     * @return 处理后的Double
     */
    public static Double null2Zero(Double number){
        return number == null ? 0 : number;
    }

    /**
     * 空值处理：Double为空时返回默认值，否则返回原值
     * @param number 原数值
     * @param defaultNumber 默认值
     * @return 处理后的Double
     */
    public static double null2Default(Double number, double defaultNumber) {
        return number == null ? defaultNumber : number;
    }

    /**
     * 空值处理：Long为空时返回0L，否则返回原值
     * @param number 原数值
     * @return 处理后的Long
     */
    public static Long null2Zero(Long number){
        return number == null ? 0L : number;
    }


    /**
     * Double数值保留2位小数（四舍五入）
     * @param number 原数值
     * @return 保留2位小数后的Double
     */
    public static Double setScale(Double number) {
        return new BigDecimal(number)
                .setScale(2, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 比较两个Integer是否相等（均非空时才比较）
     * @param number1 数值1
     * @param number2 数值2
     * @return true-相等；false-不相等或任一为空
     */
    public static boolean equals(Integer number1, Integer number2) {
        if(number1 == null || number2 == null){
            return false;
        }
        return number1.equals(number2);
    }

    /**
     * 整数除法，保留指定小数位（除数/被除数为0时返回0）
     * @param num1 被除数
     * @param num2 除数
     * @param scale 保留小数位数
     * @return 除法结果（Double）
     */
    public static Double divToDouble(Integer num1, Integer num2, int scale){
        if(num2 == null || num2 ==0 || num1 == null || num1 == 0) {
            return 0d;
        }
        return div(num1, num2, scale).doubleValue();
    }

    /**
     * 获取Double列表中的最大值（列表为空返回null）
     * @param data Double列表
     * @return 最大值或null
     */
    public static  Double max(List<Double> data){
        if(CollUtils.isEmpty(data)){
            return null;
        }
        return data.stream()
                .max(Comparator.comparingDouble(num -> num))
                .orElse(0d);
    }

    /**
     * 获取Double列表中的最小值（列表为空返回null）
     * @param data Double列表
     * @return 最小值或null
     */
    public static  Double min(List<Double> data){
        if(CollUtils.isEmpty(data)){
            return null;
        }
        return data.stream()
                .min(Comparator.comparingDouble(num -> num))
                .orElse(0d);
    }

    /**
     * 计算Double列表的平均值（列表为空返回0）
     * @param data Double列表
     * @return 平均值
     */
    public static Double average(List<Double> data){
        if(CollUtils.isEmpty(data)){
            return 0d;
        }
        return data.stream()
                .collect(Collectors.averagingDouble(Double::doubleValue));

    }

    /**
     * 将对象转换为Integer（仅支持Integer类型对象，否则返回null）
     * @param obj 待转换对象
     * @return 转换后的Integer或null
     */
    public static Integer toInt(Object obj) {
        return obj == null ? null
                : obj instanceof Integer
                ? (int) obj : null;
    }


    /**
     * 取Integer的绝对值（为空时返回0）
     * @param number 原数值
     * @return 绝对值
     */
    public static int abs(Integer number) {
        return number == null
                ? 0
                : Math.abs(number);
    }

    /**
     * 数字格式化：不足指定位数时前置补0
     * @param originNumber 原始数字
     * @param digit 目标位数
     * @return 补0后的字符串
     */
    public static String  repair0(Integer originNumber, Integer digit){
        StringBuilder number = new StringBuilder(originNumber + "");
        while (number.length() < digit) {
            number.insert(0, "0");
        }
        return number.toString();
    }

    /**
     * 空值处理：Integer为空时返回默认值，否则返回原值
     * @param originNumber 原数值
     * @param defaultNumber 默认值
     * @return 处理后的Integer
     */
    public static Integer null2Default(Integer originNumber, int defaultNumber) {
        return originNumber == null ? defaultNumber : originNumber;
    }

    /**
     * 空值处理：Long为空时返回默认值，否则返回原值
     * @param originNumber 原数值
     * @param defaultNumber 默认值
     * @return 处理后的Long
     */
    public static Long null2Default(Long originNumber, long defaultNumber) {
        return originNumber == null ? defaultNumber : originNumber;
    }
}
